The Atari Compendium/The Atari Compendium (Toad Computers) (1994).iso/files/prgtools/gnustuff/tos/updates/update17.zoo/util/diffs

Text File | 1992-03-08 | 25.5 KB | 1,166 lines

*** 1.24    1992/01/14 19:49:15
--- Changelog    1992/03/08 17:24:48
***************
*** 254,256 ****
--- 254,261 ----
      use gnu-out.h instead of gnu-out.old.

  ----------------------------- Patchlevel 24 ---------------------------------
+
+ cplusdem.c:: ++jrb
+     update C++ demangler for gcc 2.0
+
+ ----------------------------- Patchlevel 25 ---------------------------------
*** 1.22    1992/01/14 19:47:11
--- PatchLev.h    1992/03/08 17:24:49
***************
*** 1,4 ****
! #define PatchLevel "24"

  /*
   *    the Patch Level above is to identify the version
--- 1,4 ----
! #define PatchLevel "25"

  /*
   *    the Patch Level above is to identify the version
*** 1.1    1991/07/23 22:43:21
--- cplusdem.c    1992/03/08 17:24:51
***************
*** 1,10 ****
  /* Demangler for GNU C++
!    Copyright (C) 1989 Free Software Foundation, Inc.
     written by James Clark ([e-mail])

     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
!    the Free Software Foundation; either version 1, or (at your option)
     any later version.

     This program is distributed in the hope that it will be useful,
--- 1,10 ----
  /* Demangler for GNU C++
!    Copyright (C) 1989, 1992 Free Software Foundation, Inc.
     written by James Clark ([e-mail])

     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
!    the Free Software Foundation; either version 2, or (at your option)
     any later version.

     This program is distributed in the hope that it will be useful,
***************
*** 19,31 ****
  /* This is for g++ 1.36.1 (November 6 version). It will probably
     require changes for any other version.

!    Modified for g++ 1.36.2 (November 18 version).  */

  /* This file exports one function

     char *cplus_demangle (const char *name)
!
!    If `name' is a mangled function name produced by g++, then
     a pointer to a malloced string giving a C++ representation
     of the name will be returned; otherwise NULL will be returned.
     It is the caller's responsibility to free the string which
--- 19,35 ----
  /* This is for g++ 1.36.1 (November 6 version). It will probably
     require changes for any other version.

!    Modified for g++ 1.36.2 (November 18 version).

+    Modified for g++ 1.90.06 (December 31 version).
+
+    Modified for g++ 1.95.03 (November 13 verison).  */
+
  /* This file exports one function

     char *cplus_demangle (const char *name)
!
!    If NAME is a mangled function name produced by GNU C++, then
     a pointer to a malloced string giving a C++ representation
     of the name will be returned; otherwise NULL will be returned.
     It is the caller's responsibility to free the string which
***************
*** 59,64 ****
--- 63,75 ----
  #define strrchr rindex
  #endif

+ /* This is '$' on systems where the assembler can deal with that.
+    Where the assembler can't, it's '.' (but on many systems '.' is
+    used for other things).  */
+ #if !defined (CPLUS_MARKER)
+ #define CPLUS_MARKER '$'
+ #endif
+
  #ifndef __STDC__
  #define const
  #endif
***************
*** 72,80 ****
--- 83,93 ----
  #ifdef __STDC__
  extern char *xmalloc (int);
  extern char *xrealloc (char *, int);
+ extern void free (char *);
  #else
  extern char *xmalloc ();
  extern char *xrealloc ();
+ extern void free ();
  #endif

  static char **typevec = 0;
***************
*** 85,124 ****
    const char *in;
    const char *out;
  } optable[] = {
!   "new", " new",
!   "delete", " delete",
!   "ne", "!=",
!   "eq", "==",
!   "ge", ">=",
!   "gt", ">",
!   "le", "<=",
!   "lt", "<",
!   "plus", "+",
!   "minus", "-",
!   "mult", "*",
!   "convert", "+",    /* unary + */
!   "negate", "-",    /* unary - */
!   "trunc_mod", "%",
!   "trunc_div", "/",
!   "truth_andif", "&&",
!   "truth_orif", "||",
!   "truth_not", "!",
!   "postincrement", "++",
!   "postdecrement", "--",
!   "bit_ior", "|",
!   "bit_xor", "^",
!   "bit_and", "&",
!   "bit_not", "~",
!   "call", "()",
!   "cond", "?:",
!   "alshift", "<<",
!   "arshift", ">>",
!   "component", "->",
!   "indirect", "*",
!   "method_call", "->()",
!   "addr", "&",        /* unary & */
!   "array", "[]",
!   "nop", "",            /* for operator= */
  };

  /* Beware: these aren't '\0' terminated. */
--- 98,171 ----
    const char *in;
    const char *out;
  } optable[] = {
!   "nw", " new",            /* new (1.92, ansi) */
!   "dl", " delete",        /* new (1.92, ansi) */
!   "new", " new",        /* old (1.91) */
!   "delete", " delete",        /* old (1.91) */
!   "ne", "!=",            /* old, ansi */
!   "eq", "==",            /* old, ansi */
!   "ge", ">=",            /* old, ansi */
!   "gt", ">",            /* old, ansi */
!   "le", "<=",            /* old, ansi */
!   "lt", "<",            /* old, ansi */
!   "plus", "+",            /* old */
!   "pl", "+",            /* ansi */
!   "apl", "+=",            /* ansi */
!   "minus", "-",            /* old */
!   "mi", "-",            /* ansi */
!   "ami", "-=",            /* ansi */
!   "mult", "*",            /* old */
!   "ml", "*",            /* ansi */
!   "aml", "*=",            /* ansi */
!   "convert", "+",        /* old (unary +) */
!   "negate", "-",        /* old (unary -) */
!   "trunc_mod", "%",        /* old */
!   "md", "%",            /* ansi */
!   "amd", "%=",            /* ansi */
!   "trunc_div", "/",        /* old */
!   "dv", "/",            /* ansi */
!   "adv", "/=",            /* ansi */
!   "truth_andif", "&&",        /* old */
!   "aa", "&&",            /* ansi */
!   "truth_orif", "||",        /* old */
!   "oo", "||",            /* ansi */
!   "truth_not", "!",        /* old */
!   "nt", "!",            /* ansi */
!   "postincrement", "++",    /* old */
!   "pp", "++",            /* ansi */
!   "postdecrement", "--",    /* old */
!   "mm", "--",            /* ansi */
!   "bit_ior", "|",        /* old */
!   "or", "|",            /* ansi */
!   "aor", "|=",            /* ansi */
!   "bit_xor", "^",        /* old */
!   "er", "^",            /* ansi */
!   "aer", "^=",            /* ansi */
!   "bit_and", "&",        /* old */
!   "ad", "&",            /* ansi */
!   "aad", "&=",            /* ansi */
!   "bit_not", "~",        /* old */
!   "co", "~",            /* ansi */
!   "call", "()",            /* old */
!   "cl", "()",            /* ansi */
!   "cond", "?:",            /* old */
!   "alshift", "<<",        /* old */
!   "ls", "<<",            /* ansi */
!   "als", "<<=",            /* ansi */
!   "arshift", ">>",        /* old */
!   "rs", ">>",            /* ansi */
!   "ars", ">>=",            /* ansi */
!   "component", "->",        /* old */
!   "rf", "->",            /* ansi */
!   "indirect", "*",        /* old */
!   "method_call", "->()",    /* old */
!   "addr", "&",            /* old (unary &) */
!   "array", "[]",        /* old */
!   "vc", "[]",            /* ansi */
!   "compound", ",",        /* old */
!   "cm", ",",            /* ansi */
!   "nop", "",            /* old (for operator=) */
!   "as", "=",            /* ansi */
  };

  /* Beware: these aren't '\0' terminated. */
***************
*** 171,176 ****
--- 218,246 ----
  static void remember_type ();
  #endif

+ int
+ get_simple_count (type, res)
+      char **type;
+      int *res;
+ {
+   int n = 0, success = 1;;
+
+   do
+     {
+       n *= 10;
+       n += **type - '0';
+       *type += 1;
+     }
+   while (isdigit (**type));
+   if (strlen (*type) < n)
+     {
+       success = 0;
+     }
+
+   *res = n;
+   return success;
+ }
+
  char *
  cplus_demangle (type)
       const char *type;
***************
*** 179,184 ****
--- 249,256 ----
    int n;
    int success = 0;
    int constructor = 0;
+   int destructor = 0;
+   int static_type = 0;
    int const_flag = 0;
    int i;
    const char *p;
***************
*** 198,225 ****
    if (*p == '\0')
      {
        /* destructor */
!       if (type[0] == '_' && type[1] == '$' && type[2] == '_')
      {
!       int n = (strlen (type) - 3)*2 + 3 + 2 + 1;
!       char *tem = (char *) xmalloc (n);
!       strcpy (tem, type + 3);
!       strcat (tem, "::~");
!       strcat (tem, type + 3);
!       strcat (tem, "()");
!       return tem;
      }
        /* static data member */
!       if (*type != '_' && (p = strchr (type, '$')) != NULL)
      {
!       int n = strlen (type) + 2;
!       char *tem = (char *) xmalloc (n);
!       memcpy (tem, type, p - type);
!       strcpy (tem + (p - type), "::");
!       strcpy (tem + (p - type) + 2, p + 1);
!       return tem;
      }
!       /* virtual table */
!       if (type[0] == '_' && type[1] == 'v' && type[2] == 't' && type[3] == '$')
      {
        int n = strlen (type + 4) + 14 + 1;
        char *tem = (char *) xmalloc (n);
--- 270,288 ----
    if (*p == '\0')
      {
        /* destructor */
!       if (type[0] == '_' && type[1] == CPLUS_MARKER && type[2] == '_')
      {
!       destructor = 1;
!       p = type;
      }
        /* static data member */
!       else if (*type != '_' && (strchr (type, CPLUS_MARKER) != NULL))
      {
!       static_type = 1;
!       p = type;
      }
!       /* virtual table "_vt$"  */
!       else if (type[0] == '_' && type[1] == 'v' && type[2] == 't' && type[3] == CPLUS_MARKER)
      {
        int n = strlen (type + 4) + 14 + 1;
        char *tem = (char *) xmalloc (n);
***************
*** 227,252 ****
        strcat (tem, " virtual table");
        return tem;
      }
!       return NULL;
      }

    string_init (&decl);

!   if (p == type)
      {
!       if (!isdigit (p[2]))
      {
        string_delete (&decl);
        return NULL;
      }
!       constructor = 1;
      }
    else
      {
        string_appendn (&decl, type, p - type);
        munge_function_name (&decl);
      }
-   p += 2;

  #ifndef LONGERNAMES
    premangle = p;
--- 290,348 ----
        strcat (tem, " virtual table");
        return tem;
      }
!       else return NULL;
      }

    string_init (&decl);

!   if (static_type)
!     {
!       if (!isdigit (p[0]) && ('t' != p[0]))
!     {
!       string_delete (&decl);
!       return NULL;
!     }
!     }
!   else if (destructor)
      {
!       if (!isdigit (p[3])&& ('t' != p[3]))
      {
        string_delete (&decl);
        return NULL;
      }
!       p += 3;
!     }
!   else if (p == type)
!     {
!       if (!isdigit (p[2]) && ('t' != p[2]))
!     {
!       p += 1;
!       while (*p != '\0' && !(*p == '_' && p[1] == '_'))
!         p++;
!       string_appendn (&decl, type, p - type);
!       string_appendn (&decl, "", 1);
!       munge_function_name (&decl);
!       if (decl.b[0] == '_')
!         {
!           string_delete (&decl);
!           return NULL;
!         }
!       else
!         p += 2;
!     }
!       else
!     {
!       constructor = 1;
!       p += 2;
!     }
      }
    else
      {
        string_appendn (&decl, type, p - type);
+       decl.p[0] = '0';
        munge_function_name (&decl);
+       p += 2;
      }

  #ifndef LONGERNAMES
    premangle = p;
***************
*** 286,295 ****
        string_delete (&decl);
        return NULL;
      }
!       if (constructor)
      {
        string_appendn (&decl, p, n);
        string_append (&decl, "::");
        string_appendn (&decl, p, n);
      }
        else
--- 382,393 ----
        string_delete (&decl);
        return NULL;
      }
!       if (constructor || destructor)
      {
        string_appendn (&decl, p, n);
        string_append (&decl, "::");
+       if (destructor)
+         string_append(&decl, "~");
        string_appendn (&decl, p, n);
      }
        else
***************
*** 301,307 ****
  #ifndef LONGERNAMES
        remember_type (premangle, p - premangle);
  #endif
!       success = do_args (&p, &decl);
        if (const_flag)
      string_append (&decl, " const");
        break;
--- 399,412 ----
  #ifndef LONGERNAMES
        remember_type (premangle, p - premangle);
  #endif
!       if (static_type)
!     {
!       string_append(&decl, p+1);
!       p += strlen(p);
!       success = 1;
!     }
!       else
!     success = do_args (&p, &decl);
        if (const_flag)
      string_append (&decl, " const");
        break;
***************
*** 309,314 ****
--- 414,609 ----
        p += 1;
        success = do_args (&p, &decl);
        break;
+     /* template additions */
+     case 't':
+       p += 1;
+       {
+     int r, i;
+     int non_empty = 0;
+     string tname;
+     string trawname;
+
+     string temp;
+     int need_comma = 0;
+
+     string_init(&tname);
+     string_init(&trawname);
+
+     /* get template name */
+     if (!get_simple_count (&p, &r))
+       {
+         string_delete (&decl);
+         return 0;
+       }
+     string_appendn (&tname, p, r);
+     string_appendn (&trawname, p, r);
+     string_appendn (&trawname, "", 1);
+     p += r;
+     string_append (&tname, "<");
+     /* get size of template parameter list */
+     if (!get_count (&p, &r))
+       return 0;
+     for (i = 0; i < r; i++)
+       {
+         if (need_comma)
+           string_append (&tname, ", ");
+         /* Z for type parameters */
+         if (*p == 'Z')
+           {
+         p += 1;
+
+         success = do_type (&p, &temp);
+         string_appendn (&temp, "", 1);
+         if (success)
+           string_append (&tname, temp.b);
+         string_delete(&temp);
+         if (!success)
+           break;
+           }
+         /* otherwise, value parameter */
+         else
+           {
+         const char *old_p  = p;
+         int is_pointer = 0;
+         int is_real = 0;
+         int is_integral = 0;
+         int done = 0;
+
+         success = do_type (&p, &temp);
+         string_appendn (&temp, "", 1);
+         if (success)
+           string_append (&tname, temp.b);
+         string_delete(&temp);
+         if (!success)
+           break;
+         string_append (&tname, "=");
+         while (*old_p && !done)
+           {
+             switch (*old_p)
+               {
+               case 'P':
+               case 'R':
+             done = is_pointer = 1;
+             break;
+               case 'C':    /* const */
+               case 'U':    /* unsigned */
+               case 'V':    /* volatile */
+               case 'F':    /* function */
+               case 'M':    /* member function */
+               case 'O':    /* ??? */
+             old_p++;
+             continue;
+               case 'Q':    /* repetition of following */
+               case 'T':    /* remembered type */
+             abort();
+             break;
+               case 'v':    /* void */
+             abort();
+             break;
+               case 'x':    /* long long */
+               case 'l':    /* long */
+               case 'i':    /* int */
+               case 's':    /* short */
+               case 'c':    /* char */
+             done = is_integral = 1;
+             break;
+               case 'r':    /* long double */
+               case 'd':    /* double */
+               case 'f':    /* float */
+             done = is_real = 1;
+             break;
+               default:
+             abort();
+               }
+           }
+         if (is_integral)
+           {
+             if (*p == 'm')
+               {
+             string_appendn (&tname, "-", 1);
+             p++;
+               }
+             while (isdigit (*p))
+               {
+             string_appendn (&tname, p, 1);
+             p++;
+               }
+           }
+         else if (is_real)
+           {
+             if (*p == 'm')
+               {
+             string_appendn (&tname, "-", 1);
+             p++;
+               }
+             while (isdigit (*p))
+               {
+             string_appendn (&tname, p, 1);
+             p++;
+               }
+             if (*p == '.') /* fraction */
+               {
+             string_appendn (&tname, ".", 1);
+             p++;
+             while (isdigit (*p))
+               {
+                 string_appendn (&tname, p, 1);
+                 p++;
+               }
+               }
+             if (*p == 'e') /* exponent */
+               {
+             string_appendn (&tname, "e", 1);
+             p++;
+             while (isdigit (*p))
+               {
+                 string_appendn (&tname, p, 1);
+                 p++;
+               }
+               }
+           }
+         else if (is_pointer)
+           {
+             int symbol_len;
+
+             if (!get_count (&p, &symbol_len))
+               {
+             success = 0;
+             break;
+               }
+             string_appendn (&tname, p, symbol_len);
+             p += symbol_len;
+           }
+           }
+         need_comma = 1;
+       }
+     string_append (&tname, ">::");
+     if (destructor)
+       string_append(&tname, "~");
+     if (constructor || destructor) {
+       string_appendn (&trawname, "", 1);
+       string_append (&tname, trawname.b);
+     }
+     string_delete(&trawname);
+
+     if (!success) {
+       string_delete(&tname);
+       return 0;
+     }
+     string_appendn (&tname, "", 1);
+     string_prepend (&decl, tname.b);
+     string_delete (&tname);
+
+     if (static_type)
+       {
+         string_append (&decl, p+1);
+         p += strlen (p);
+         success = 1;
+       }
+     else
+       success = do_args (&p, &decl);
+     break;
+       }
      }

    for (i = 0; i < ntypes; i++)
***************
*** 343,349 ****
      return 0;
    *count = **type - '0';
    *type += 1;
!   /* see flush_repeats in cplus-method.c */
    if (isdigit (**type))
      {
        const char *p = *type;
--- 638,644 ----
      return 0;
    *count = **type - '0';
    *type += 1;
!   /* see flush_repeats in cp-method.c */
    if (isdigit (**type))
      {
        const char *p = *type;
***************
*** 388,393 ****
--- 683,697 ----
        int member;
        switch (**type)
      {
+     case 'Q':
+       n = (*type)[1] - '0';
+       if (n < 0 || n > 9)
+         success = 0;
+       *type += 2;
+       while (n-- > 0)
+         do_type (type, result);
+       break;
+
      case 'P':
        *type += 1;
        string_prepend (&decl, "*");
***************
*** 491,497 ****
            string_append (&decl, " ");
          else
            non_empty = 1;
!         string_append (&decl, "volatilep");
            }
          break;
        }
--- 795,801 ----
            string_append (&decl, " ");
          else
            non_empty = 1;
!         string_append (&decl, "volatile");
            }
          break;
        }
***************
*** 513,520 ****
      }
      }

-   done = 0;
    non_empty = 0;
    while (success && !done)
      {
        switch (**type)
--- 817,856 ----
      }
      }

    non_empty = 0;
+   if (success)
+     success = do_cuv_prefix (type, result, &non_empty);
+
+   if (success)
+     success = do_builtin_type(type, result, &non_empty);
+
+   if (success)
+     {
+       if (!string_empty (&decl))
+     {
+       string_append (result, " ");
+       string_appends (result, &decl);
+     }
+       string_delete (&decl);
+       return 1;
+     }
+   else
+     {
+       string_delete (&decl);
+       string_delete (result);
+       return 0;
+     }
+ }
+
+ int
+ do_cuv_prefix (type, result, non_empty)
+      char **type;
+      string* result;
+      int* non_empty;
+ {
+   int success = 1;
+   int done = 0;
+
    while (success && !done)
      {
        switch (**type)
***************
*** 521,546 ****
      {
      case 'C':
        *type += 1;
!       if (non_empty)
          string_append (result, " ");
        else
!         non_empty = 1;
        string_append (result, "const");
        break;
      case 'U':
        *type += 1;
!       if (non_empty)
          string_append (result, " ");
        else
!         non_empty = 1;
        string_append (result, "unsigned");
        break;
      case 'V':
        *type += 1;
!       if (non_empty)
          string_append (result, " ");
        else
!         non_empty = 1;
        string_append (result, "volatile");
        break;
      default:
--- 857,882 ----
      {
      case 'C':
        *type += 1;
!       if (*non_empty)
          string_append (result, " ");
        else
!         *non_empty = 1;
        string_append (result, "const");
        break;
      case 'U':
        *type += 1;
!       if (*non_empty)
          string_append (result, " ");
        else
!         *non_empty = 1;
        string_append (result, "unsigned");
        break;
      case 'V':
        *type += 1;
!       if (*non_empty)
          string_append (result, " ");
        else
!         *non_empty = 1;
        string_append (result, "volatile");
        break;
      default:
***************
*** 548,671 ****
        break;
      }
      }
!
!   if (success)
!     switch (**type)
!       {
!       case '\0':
!       case '_':
!     break;
!       case 'v':
!     *type += 1;
!     if (non_empty)
!       string_append (result, " ");
!     string_append (result, "void");
!     break;
!       case 'x':
!     *type += 1;
!     if (non_empty)
!       string_append (result, " ");
!     string_append (result, "long long");
!     break;
!       case 'l':
!     *type += 1;
!     if (non_empty)
!       string_append (result, " ");
!     string_append (result, "long");
!     break;
!       case 'i':
!     *type += 1;
!     if (non_empty)
!       string_append (result, " ");
!     string_append (result, "int");
!     break;
!       case 's':
!     *type += 1;
!     if (non_empty)
!       string_append (result, " ");
!     string_append (result, "short");
!     break;
!       case 'c':
!     *type += 1;
!     if (non_empty)
!       string_append (result, " ");
!     string_append (result, "char");
!     break;
!       case 'r':
!     *type += 1;
!     if (non_empty)
!       string_append (result, " ");
!     string_append (result, "long double");
!     break;
!       case 'd':
!     *type += 1;
!     if (non_empty)
!       string_append (result, " ");
!     string_append (result, "double");
!     break;
!       case 'f':
!     *type += 1;
!     if (non_empty)
!       string_append (result, " ");
!     string_append (result, "float");
!     break;
!       case 'G':
!     *type += 1;
!     if (!isdigit (**type))
!       {
!         success = 0;
!         break;
!       }
!     /* fall through */
!       case '0':
!       case '1':
!       case '2':
!       case '3':
!       case '4':
!       case '5':
!       case '6':
!       case '7':
!       case '8':
!       case '9':
!     n = 0;
!     do
!       {
!         n *= 10;
!         n += **type - '0';
!         *type += 1;
!       }
!     while (isdigit (**type));
!     if (strlen (*type) < n)
!       {
!         success = 0;
!         break;
!       }
!     if (non_empty)
!       string_append (result, " ");
!     string_appendn (result, *type, n);
!     *type += n;
!     break;
!       default:
!     success = 0;
!     break;
!       }

!   if (success)
      {
!       if (!string_empty (&decl))
      {
!       string_append (result, " ");
!       string_appends (result, &decl);
      }
!       string_delete (&decl);
!       return 1;
!     }
!   else
!     {
!       string_delete (&decl);
!       string_delete (result);
!       return 0;
      }
  }

  /* `result' will be initialised in do_type; it will be freed on failure */
--- 884,1001 ----
        break;
      }
      }
!   return success;
! }

! int
! do_builtin_type (type, result, non_empty)
!      char **type;
!      string* result;
!      int *non_empty;
! {
!   int success = 1;
!   int n;
!
!   switch (**type)
      {
!     case '\0':
!     case '_':
!       break;
!     case 'v':
!       *type += 1;
!       if (*non_empty)
!     string_append (result, " ");
!       string_append (result, "void");
!       break;
!     case 'x':
!       *type += 1;
!       if (*non_empty)
!     string_append (result, " ");
!       string_append (result, "long long");
!       break;
!     case 'l':
!       *type += 1;
!       if (*non_empty)
!     string_append (result, " ");
!       string_append (result, "long");
!       break;
!     case 'i':
!       *type += 1;
!       if (*non_empty)
!     string_append (result, " ");
!       string_append (result, "int");
!       break;
!     case 's':
!       *type += 1;
!       if (*non_empty)
!     string_append (result, " ");
!       string_append (result, "short");
!       break;
!     case 'c':
!       *type += 1;
!       if (*non_empty)
!     string_append (result, " ");
!       string_append (result, "char");
!       break;
!     case 'r':
!       *type += 1;
!       if (*non_empty)
!     string_append (result, " ");
!       string_append (result, "long double");
!       break;
!     case 'd':
!       *type += 1;
!       if (*non_empty)
!     string_append (result, " ");
!       string_append (result, "double");
!       break;
!     case 'f':
!       *type += 1;
!       if (*non_empty)
!     string_append (result, " ");
!       string_append (result, "float");
!       break;
!     case 'G':
!       *type += 1;
!       if (!isdigit (**type))
      {
!       success = 0;
!       break;
      }
!       /* fall through */
!     case '0':
!     case '1':
!     case '2':
!     case '3':
!     case '4':
!     case '5':
!     case '6':
!     case '7':
!     case '8':
!     case '9':
!       n = 0;
!       do
!     {
!       n *= 10;
!       n += **type - '0';
!       *type += 1;
!     }
!       while (isdigit (**type));
!       if (strlen (*type) < n)
!     {
!       success = 0;
!       break;
!     }
!       if (*non_empty)
!     string_append (result, " ");
!       string_appendn (result, *type, n);
!       *type += n;
!       break;
!     default:
!       success = 0;
!       break;
      }
+   return success;
  }

  /* `result' will be initialised in do_type; it will be freed on failure */
***************
*** 773,780 ****
  munge_function_name (name)
       string *name;
  {
!   if (!string_empty (name) && name->p - name->b >= 3
!       && name->b[0] == 'o' && name->b[1] == 'p' && name->b[2] == '$')
      {
        int i;
        /* see if it's an assignment expression */
--- 1103,1113 ----
  munge_function_name (name)
       string *name;
  {
!   if (string_empty (name))
!     return;
!
!   if (name->p - name->b >= 3
!       && name->b[0] == 'o' && name->b[1] == 'p' && name->b[2] == CPLUS_MARKER)
      {
        int i;
        /* see if it's an assignment expression */
***************
*** 812,819 ****
      }
        return;
      }
!   else if (!string_empty (name) && name->p - name->b >= 5
!        && memcmp (name->b, "type$", 5) == 0)
      {
        /* type conversion operator */
        string type;
--- 1145,1151 ----
      }
        return;
      }
!   else if (name->p - name->b >= 5 && memcmp (name->b, "type$", 5) == 0)
      {
        /* type conversion operator */
        string type;
***************
*** 825,830 ****
--- 1157,1215 ----
        string_appends (name, &type);
        string_delete (&type);
        return;
+     }
+     }
+   /* ANSI.  */
+   else if (name->b[2] == 'o' && name->b[3] == 'p')
+     {
+       /* type conversion operator.  */
+       string type;
+       const char *tem = name->b + 4;
+       if (do_type (&tem, &type))
+     {
+       string_clear (name);
+       string_append (name, "operator ");
+       string_appends (name, &type);
+       string_delete (&type);
+       return;
+     }
+     }
+   else if (name->b[2] >= 'a' && name->b[2] <= 'z'
+        && name->b[3] >= 'a' && name->b[3] <= 'z')
+     {
+       int i;
+
+       if (name->b[4] == '\0')
+     {
+       /* Operator.  */
+       for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++)
+         {
+           if (strlen (optable[i].in) == 2
+           && memcmp (optable[i].in, name->b + 2, 2) == 0)
+         {
+           string_clear (name);
+           string_append (name, "operator");
+           string_append (name, optable[i].out);
+           return;
+         }
+         }
+     }
+       else
+     {
+       if (name->b[2] != 'a' || name->b[5] != '\0')
+         return;
+       /* Assignment.  */
+       for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++)
+         {
+           if (strlen (optable[i].in) == 3
+           && memcmp (optable[i].in, name->b + 2, 3) == 0)
+         {
+           string_clear (name);
+           string_append (name, "operator");
+           string_append (name, optable[i].out);
+           return;
+         }
+         }
      }
      }
  }